# -*- coding: utf-8 -*-

import sqlite3

from config.preferences import CADASTRO_DB, VNA_DB


class DataBase(object):

    def __init__(self):
        """
            Construtor.
        """
        self.vna = VNA_DB
        self.cadastro = CADASTRO_DB



    def criarTabela(self):
        """
            Metodo para criar uma nova tabela.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        cursor.execute("""CREATE TABLE produtos
                        (id_produto INTEGER PRIMARY KEY
                        AUTOINCREMENT UNIQUE NOT NULL,
                        produto TEXT NOT NULL,
                        radical INTEGER NOT NULL)""")
        cursor.execute("""CREATE TABLE entrada(
                                                id_produto_entrada INTEGER NOT
                                                NULL, num_antena INTEGER NOT
                                                NULL, FOREIGN KEY(
                                                id_produto_entrada)
                                                REFERENCES produtos)""")
        connection.commit()
        connection.close()



    def cadastrarNovoProduto(self, faixa, produto, radical, num_antena):
        """
            Metodo para cadastrar um novo produto na tabela de produtos ja
            existente. Insira o nome do produto e o seu radical parao
            numero de serie.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        cursor.execute("""INSERT INTO produtos(
                       faixa, produto, radical) VALUES(?, ?, ?)""",
                       (faixa, produto, radical))
        connection.commit()
        connection.close()
        
        connection2 = sqlite3.connect(self.cadastro)
        cursor2 = connection2.cursor()
        cursor2.execute(
                        """INSERT INTO produtos(
                        faixa, produto, radical,num_antena)
                        VALUES(?, ?, ?, ?)""",
                        (faixa, produto, radical, num_antena))
        connection2.commit()
        connection2.close()



    def adicionarEntrada(
                         self, id_produto_entrada,
                         num_serie, ord_producao,
                         num_pedido, plot, date, status):
        """
            Metodo para adicionar uma entrada ao banco.
            Insira o id do produto a ser adicionado e o numero dele.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        cursor.execute("""INSERT INTO entrada(
                                              id_produto_entrada,
                                              num_serie,
                                              ord_producao,
                                              num_pedido,
                                              plot,
                                              date,
                                              status)
                                              VALUES(?, ?, ?, ?, ?, ?, ?)""",(
                                              id_produto_entrada,
                                              num_serie,
                                              ord_producao,
                                              num_pedido,
                                              plot,
                                              date,
                                              status,))
        connection.commit()
        connection.close()



    def produtosCadastrados(self):
        """
            Metodo que retorna todos os produtos que estao disponiveis no banco,
            ou seja, os produtos que estao cadastrados.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT produto FROM produtos""")
        response = [row[0] for row in results.fetchall()]
        connection.close()
        return(response)



    def inserirNumPedido(self, num_pedido, id_produto, num_serie):
        """

        """
        status = "Pedido"
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        cursor.execute("""UPDATE entrada SET num_pedido=? 
                        WHERE id_produto_entrada=? AND num_serie=?""",
                        (num_pedido, id_produto, num_serie,))
        cursor.execute("""UPDATE entrada SET status=? 
                        WHERE id_produto_entrada=? AND num_serie=?""",
                        (status, id_produto, num_serie,))
        connection.commit()
        connection.close()



    def removerNumPedido(self, numPedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT num_serie FROM entrada WHERE
                                 num_pedido=?""",
                                 (numPedido,))
        msg = "Producao"
        vet_num_serie = [row[0] for row in results.fetchall()]
        for num_serie in vet_num_serie:
            cursor.execute(
                           """UPDATE entrada SET status=? WHERE num_serie=?""",
                           (msg, num_serie,))
            cursor.execute(
                           """UPDATE entrada SET num_pedido=0 WHERE num_serie=?""",
                           (num_serie,))
            connection.commit()
        connection.close()



    def getNumSeriesFromProduto(self, id_produto):
        """
            Metodo que retorna um vetor com o modelo do produto, radical, e 
            todos os numeros de serie disponiveis.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute(
                                """SELECT produto FROM produtos WHERE 
                                id_produto=?""",
                                (id_produto,))
        produto = results.fetchone()
        results = cursor.execute(
                                """SELECT num_serie FROM entrada WHERE 
                                id_produto_entrada=?""",
                                (id_produto,))
        num_serie = [row[0] for row in results.fetchall()]
        results = cursor.execute(
                                """SELECT ord_producao FROM entrada WHERE 
                                id_produto_entrada=?""",
                                (id_produto,))
        ord_producao = [row[0] for row in results.fetchall()]
        results = cursor.execute(
                                """SELECT num_pedido FROM entrada WHERE 
                                id_produto_entrada=?""",
                                (id_produto,))
        num_pedido = [row[0] for row in results.fetchall()]
        results = cursor.execute(
                                """SELECT status FROM entrada WHERE 
                                id_produto_entrada=?""",
                                (id_produto,))
        status = [row[0] for row in results.fetchall()]
        response = [produto, num_serie, ord_producao, num_pedido, status]
        connection.close()
        return response



    def getInfoFromProduto(self, id_produto):
        """
            Metodo que retorna um vetor com o modelo do produto, radical, e 
            todos os numeros de serie disponiveis.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT produto FROM produtos WHERE
                                  id_produto=?""",
                                  (id_produto,))
        produto = results.fetchone()
        results = cursor.execute("""SELECT num_serie, ord_producao FROM entrada 
                                 WHERE id_produto_entrada=? AND num_pedido==0""",
                                 (id_produto,))
        num_ord = results.fetchall()
        response = [produto, num_ord]
        connection.close()
        return response



    def getQtDeProdutosDisponiveis(self, id_produto):
        """

        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT num_serie FROM entrada WHERE
                                 id_produto_entrada=? AND num_pedido=0""",
                                 (id_produto,))
        _quantidade = [row[0] for row in results.fetchall()]
        quantidade = len(_quantidade)
        connection.close()
        return quantidade



    def getIdFromProduto(self, produto):
        """
            Metodo que retorna o ID do produto passado como argumento.
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT id_produto FROM produtos WHERE
                                 produto=?""", (produto,))
        response = results.fetchone()
        response = response[0]
        connection.close()
        return response



    def getNumSerieDb(self, produto):
        """

        """
        connection = sqlite3.connect(self.cadastro)
        cursor = connection.cursor()
        produto = str(produto)
        results = cursor.execute("""SELECT radical, num_antena FROM produtos
                                  WHERE produto=?""", (produto,))
        response = results.fetchone()
        connection.close()
        return response



    def getQtNumPedido(self, numPedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        num_pedido = str(numPedido)
        results = cursor.execute("""SELECT id_produto_entrada FROM entrada
                                  WHERE num_pedido=?""", (num_pedido,))
        response = [row[0] for row in results.fetchall()]
        response = len(response)
        connection.close()
        return response



    def getNomeProduto(self, id_produto):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT produto FROM produtos
                                  WHERE id_produto=?""", (id_produto,))
        response = results.fetchone()
        connection.close()
        return response



    def getStatusPedido(self, num_pedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT status FROM entrada
                                  WHERE num_pedido=?""", (num_pedido,))
        response = results.fetchone()
        connection.close()
        return response



    def popularTree(self, faixa):
        """ 
        
        """
        connection = sqlite3.connect(self.cadastro)
        cursor = connection.cursor()
        results = cursor.execute(
                                 """SELECT produto FROM produtos 
                                 WHERE faixa=?""",
                                 (faixa,))
        response = results.fetchall()
        connection.close()
        return(response)



    def getFaixas(self):
        """
        
        """
        connection = sqlite3.connect(self.cadastro)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT faixa FROM produtos""")
        response = results.fetchall()
        connection.close()
        return(response)



    def updateNumeroAntena(self, produto, numeroAntena):
        """

        """
        connection = sqlite3.connect(self.cadastro)
        cursor = connection.cursor()
        produto = str(produto)
        numeroAntena = str(numeroAntena)
        cursor.execute("""UPDATE produtos SET num_antena=? WHERE produto=?""",
                       (numeroAntena, produto,))
        connection.commit()
        connection.close()



    def pesquisarPorSerial(self, num_serie):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT id_produto_entrada, ord_producao,
                                  num_pedido FROM entrada WHERE num_serie=?""",
                                  (num_serie,))
        response = results.fetchone()
        connection.close()
        return response



    def pesquisarPorOrdProducao(self, ordProducao):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT id_produto_entrada, num_serie,
                                  num_pedido, status FROM entrada
                                  WHERE ord_producao=?""", (ordProducao,))
        response = results.fetchall()
        connection.close()
        return response



    def pesquisarPorPedido(self, numPedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT id_produto_entrada, num_serie,
                                  ord_producao, status FROM entrada
                                  WHERE num_pedido=?""", (numPedido,))
        response = results.fetchall()
        connection.close()
        return response



    def pesquisaFinalizarPedido(self, num_pedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT num_serie FROM entrada
                                  WHERE num_pedido=?""",
                                  (num_pedido,))
        response = results.fetchall()
        response2 = []
        for numSerie in response:
            numSerie = str(numSerie[0])
            results2 = cursor.execute("""SELECT id_produto_entrada FROM entrada
                                      WHERE num_serie=?""",
                                      (numSerie,))
            response2.append(results2.fetchone())
        connection.close()
        return response2



    def pesquisaPorNumPedidoIdProduto(self, id_produto, num_pedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT status FROM entrada
                                  WHERE id_produto_entrada=? AND num_pedido=?""",
                                  (id_produto, num_pedido,))
        _response = results.fetchall()
        response = len(_response)
        connection.close()
        return response


    def getPlotPath(self, num_pedido):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT plot FROM entrada
                                  WHERE num_pedido=?""",
                                  (num_pedido,))
        response = results.fetchall()
        connection.close()
        return response



    def setStatusTableChanged(self, status, num_serie):
        """
        
        """
        connection = sqlite3.connect(self.vna)
        cursor = connection.cursor()
        cursor.execute("""UPDATE entrada SET status=? WHERE num_serie=?""",
                       (status, num_serie,))
        connection.commit()
        connection.close()



    def preencherTabelaMenuEditarDb(self):
        """
        
        """
        connection = sqlite3.connect(self.cadastro)
        cursor = connection.cursor()
        results = cursor.execute("""SELECT * FROM produtos""",)
        response = results.fetchall()
        connection.close()
        return response



    def editarDb(self, id_produto, produto, radical, serial, faixa):
        """
        
        """
        connection = sqlite3.connect(self.cadastro)
        cursor = connection.cursor()
        cursor.execute("""UPDATE produtos SET produto=? WHERE id_produto=?""",
                       (produto, id_produto,))
        cursor.execute("""UPDATE produtos SET radical=? WHERE id_produto=?""",
                       (radical, id_produto,))
        cursor.execute("""UPDATE produtos SET num_antena=?
                        WHERE id_produto=?""",
                       (serial, id_produto,))
        cursor.execute("""UPDATE produtos SET faixa=? WHERE id_produto=?""",
                       (faixa, id_produto,))
        connection.commit()
        connection.close()
        
        connection2 = sqlite3.connect(self.vna)
        
        cursor2 = connection2.cursor()
        cursor2.execute("""UPDATE produtos SET produto=? WHERE id_produto=?""",
                       (produto, id_produto,))
        cursor2.execute("""UPDATE produtos SET radical=? WHERE id_produto=?""",
                       (radical, id_produto,))
        cursor2.execute("""UPDATE produtos SET faixa=? WHERE id_produto=?""",
                       (faixa, id_produto,))
        connection2.commit()
        connection2.close()
